package com.wans.job.jobhandler;

import com.alibaba.cloud.commons.lang.StringUtils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wans.apis.external.client.LotteryHistoryClient;
import com.wans.apis.lottery.client.LotterySSQClient;
import com.wans.apis.lottery.client.LotterySSQUserClient;
import com.wans.common.result.ResponseResult;
import com.wans.model.feign.huiniao.dtos.QueryData;
import com.wans.model.feign.huiniao.dtos.QueryPram;
import com.wans.model.lottery.ssq.dos.SSQ;
import com.wans.model.lottery.ssq.dos.SSQUser;
import com.xxl.job.core.context.XxlJobHelper;
import com.xxl.job.core.handler.annotation.XxlJob;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;


@Component
@Slf4j
public class SSQJobHandler {

    // 远程调用 - client
    @Autowired
    private LotteryHistoryClient lotteryHistoryClient;
    @Autowired
    private LotterySSQClient lotterySSQClient;
    @Autowired
    private LotterySSQUserClient lotterySSQUserClient;
    @Autowired
    private ObjectMapper objectMapper;

    /**
     * 获取双色历史数据的任务
     *
     * @throws JsonProcessingException json序列化异常
     */
    @XxlJob("SSQNewHistory")
    public void getNewHistory() throws JsonProcessingException {

        // 获取第三方的数据 - 构建请求参数
        QueryPram queryPram = new QueryPram();
        queryPram.setType("ssq");


        // 查询目前数据库中的最新期次数据
        ResponseResult<SSQ> ssqNewHistoryCode = lotterySSQClient.getSSQNewHistoryCode();
        SSQ newHistory = ssqNewHistoryCode.getData();
        // 数据库为 null
        if (newHistory == null) {
            // 执行当前数据库为 null 的逻辑
            XxlJobHelper.handleSuccess("请求ssq成功");
            queryPram.setLimit(200);
            queryPram.setPage(200);
            // 对方数据库中的数据结构
            ResponseResult<QueryData<Void>> dataResponseResult = lotteryHistoryClient.getHistoryTotal(queryPram);
            if (dataResponseResult.getCode() != 200) {
                XxlJobHelper.handleFail("请求External微服务出现错误");
                return;
            }
            QueryData<Void> historyTotal = dataResponseResult.getData();
            for (Integer totalPage = historyTotal.getTotalPage(); totalPage > 0; totalPage--) {
                // 循环获取 从最后一页开始
                queryPram.setPage(totalPage);
                // 一个列表的 ssq 历史数据
                ResponseResult<List<SSQ>> listResponseResult = lotteryHistoryClient.listSSQHistory(queryPram);
                if (listResponseResult.getCode() != 200) {
                    XxlJobHelper.handleFail("请求External微服务出现错误");
                    return;
                }
                List<SSQ> listSSQHistory = listResponseResult.getData();
                // 插入数据
                for (SSQ ssq : listSSQHistory) {
                    lotterySSQClient.saveNewHistoryCode(ssq);
                }
            }
        }

        // 查询到数据库中最新的数据
        // 递归更新
        if (newHistory != null) {
            ResponseResult<SSQ> lastSSQHistory = lotteryHistoryClient.getLastSSQHistory(queryPram);
            if (lastSSQHistory.getCode() != 200) {
                XxlJobHelper.handleFail("请求External微服务出现错误");
                return;
            }
            RecursionCode(lastSSQHistory.getData().getCode(), newHistory.getCode(), queryPram, false);
            // 消息
            XxlJobHelper.handleResult(200, "数据插入成功");
            XxlJobHelper.handleSuccess("数据插入成功 -> " +
                    newHistory.getCode() +
                    " - " +
                    lastSSQHistory.getData().getCode()
            );
        }

    }

    /**
     * 递归保存数据
     *
     * @param thirdMaxCode 第三方数据库中最大的期次
     * @param maxCode      我最大的期次
     */
    private boolean RecursionCode(String thirdMaxCode, String maxCode, QueryPram queryPram, Boolean isFail) throws JsonProcessingException {

        log.info("thirdMaxCode -> {}, maxCode -> {}", thirdMaxCode, maxCode);
        if (thirdMaxCode.equals(maxCode))
            return true;

        // 获取最新期次 - 本数据库
        ResponseResult<SSQ> ssqNewHistoryCode = lotterySSQClient.getSSQNewHistoryCode();
        SSQ newHistory = ssqNewHistoryCode.getData();

        queryPram.setCode(Integer.valueOf(newHistory.getNextCode()));
        // 获取需要的下期期次 - 别人的
        ResponseResult<SSQ> ssqHistory = lotteryHistoryClient.getSSQHistory(queryPram);
        if (ssqHistory.getCode() != 200) {
            log.warn("请求External微服务出现错误");
            log.warn(objectMapper.writeValueAsString(ssqHistory));

            if (isFail)
                return false;
            // 在进行请求一次试试
            return RecursionCode(thirdMaxCode, newHistory.getCode(), queryPram, true);
        }
        SSQ history = ssqHistory.getData();
        // 保存 - 插入数据
        Integer inserted = lotterySSQClient.saveNewHistoryCode(history).getData();
        if (inserted > 0) {
            // 插入数据 消息
            log.warn("保存成功的数据 -> {}", objectMapper.writeValueAsString(history));
        }

        return RecursionCode(thirdMaxCode, history.getCode(), queryPram, false);

    }

    /**
     *  更新用户双色球数据
     */
    @XxlJob("UpdateUserRecord")
    public void updateUserSSQRecord() {
        // 获取待更新的数据
        ResponseResult<List<SSQUser>> listResponseResult = lotterySSQUserClient.listUserRecords();
        if (listResponseResult == null || listResponseResult.getCode() != 200) {
            XxlJobHelper.handleFail("查询待更新数据失败");
            return;
        }

        // 依次遍历更新
        // 目前数据库中最新的一个期次
        ResponseResult<SSQ> maxCode = lotterySSQClient.getSSQNewHistoryCode();
        for (SSQUser ssqUser : listResponseResult.getData()) {
            // 数据库中还没有该期次
            if (Integer.parseInt(ssqUser.getCode()) > Integer.parseInt(maxCode.getData().getCode())) {
                continue;
            }
            // 正好是数据库中最新的期次一期
            if (Integer.parseInt(ssqUser.getCode()) == Integer.parseInt(maxCode.getData().getCode())) {
                // 更新数据
                // - 计算奖金
                ssqUser.calculatePrize(maxCode.getData());
                // 远程调用更新数据
                lotterySSQUserClient.updateRecord(ssqUser);
                log.info("一条数据更新成功 -> {}", ssqUser);
                continue;
            }
            // 获取当前期次数据库中是否存在
            ResponseResult<SSQ> byCode = lotterySSQClient.getSSQHistoryByCode(ssqUser.getCode());
            if (byCode == null ||
                    byCode.getCode() != 200 ||
                    byCode.getData() == null ||
                    StringUtils.isBlank(byCode.getData().getCode())) {
                // 应该不会出现这个情况 - 反正失败了
                log.error("前期次数据库中是否存在 - error error!!!");
                continue;
            }

            // 计算奖金更新数据
            ssqUser.calculatePrize(byCode.getData());

            // 远程调用更新数据
            lotterySSQUserClient.updateRecord(ssqUser);
            log.info("一条数据更新成功-by2 -> {}", ssqUser);
        }

        XxlJobHelper.handleSuccess("用户更新双色球记录任务结束");

    }
}
